import axios from 'axios'
import { ElMessage } from 'element-plus'

// 根据环境决定API基础路径
const getSigninBaseURL = () => {
  // 在开发环境下使用相对路径，利用Vite代理
  if (import.meta.env.DEV) {
    return ''
  }
  // 生产环境或直接访问时使用完整URL
  return 'http://127.0.0.1:8000'
}

// 创建签到专用的axios实例
const signinApi = axios.create({
  baseURL: getSigninBaseURL(),
  timeout: 30000, // 增加超时时间，因为需要上传图片
  headers: {
    'Content-Type': 'multipart/form-data'
  }
})

// 请求拦截器 - 添加认证token
signinApi.interceptors.request.use(
  (config) => {
    const token = localStorage.getItem('userToken') || sessionStorage.getItem('userToken')
    if (token) {
      config.headers.Authorization = `Bearer ${token}`
    }
    return config
  },
  (error) => {
    return Promise.reject(error)
  }
)

// 响应拦截器 - 统一处理错误
signinApi.interceptors.response.use(
  (response) => {
    return response
  },
  (error) => {
    if (error.response) {
      const { status, data } = error.response
      
      switch (status) {
        case 400:
          // 签到人数过多
          ElMessage.error(data.message || '签到人数过多，请稍后重试')
          break
        case 401:
          ElMessage.error('登录已过期，请重新登录')
          localStorage.removeItem('userToken')
          sessionStorage.removeItem('userToken')
          window.location.href = '/login'
          break
        case 403:
          ElMessage.error('没有权限进行签到')
          break
        case 404:
          ElMessage.error('签到接口不存在')
          break
        case 413:
          ElMessage.error('图片文件过大，请选择较小的图片')
          break
        case 422:
          ElMessage.error(data.message || '签到参数验证失败')
          break
        case 500:
          ElMessage.error('服务器内部错误，请稍后重试')
          break
        default:
          ElMessage.error(data.message || '签到失败')
      }
    } else if (error.request) {
      ElMessage.error('网络连接失败，请检查网络设置')
    } else {
      ElMessage.error('签到请求配置错误')
    }
    
    return Promise.reject(error)
  }
)

/**
 * 签到相关API接口
 */
export const signinApiService = {
  /**
   * 检查签到服务器连接状态
   * @returns {Promise} 连接状态
   */
  async checkConnection() {
    try {
      console.log('检查签到服务器连接状态...')
      console.log('当前baseURL:', signinApi.defaults.baseURL)
      console.log('完整URL将是:', signinApi.defaults.baseURL + '/camera/sign-in')
      
      // 尝试发送一个简单的OPTIONS请求来检查连接
      const response = await fetch(signinApi.defaults.baseURL + '/camera/sign-in', {
        method: 'OPTIONS',
        mode: 'cors'
      })
      
      console.log('连接检查结果:', response.status)
      return {
        success: true,
        status: response.status,
        message: '服务器连接正常'
      }
    } catch (error) {
      console.error('连接检查失败:', error)
      return {
        success: false,
        error: error.message,
        message: '无法连接到签到服务器'
      }
    }
  },
  /**
   * 拍照签到
   * @param {Object} signinData 签到数据
   * @param {File|Blob} signinData.image 签到照片
   * @param {string} signinData.userId 用户ID
   * @param {string} signinData.liveName 直播名称
   * @returns {Promise} 签到结果
   */
  async signIn(signinData) {
    try {
      console.log('正在发送签到请求到:', '/camera/sign-in')
      console.log('签到数据:', {
        userId: signinData.userId,
        liveName: signinData.liveName,
        imageType: signinData.image?.type,
        imageSize: signinData.image?.size
      })
      
      // 创建FormData对象
      const formData = new FormData()
      formData.append('image', signinData.image)
      formData.append('userId', signinData.userId)
      formData.append('liveName', signinData.liveName)
      
      const response = await signinApi.post('/camera/sign-in', formData)
      console.log('签到响应:', response)
      
      // 处理成功响应
      if (response.data.code === 200) {
        ElMessage.success(response.data.message || '签到成功！')
        return {
          success: true,
          data: response.data.data, // 返回的相似度分数
          message: response.data.message
        }
      } else {
        // 处理业务错误
        ElMessage.error(response.data.message || '签到失败')
        return {
          success: false,
          data: null,
          message: response.data.message
        }
      }
    } catch (error) {
      console.error('签到失败:', error)
      throw error
    }
  },

  /**
   * 将base64图片转换为Blob对象
   * @param {string} dataURL base64图片
   * @param {string} filename 文件名
   * @returns {Blob} Blob对象
   */
  dataURLtoBlob(dataURL, filename = 'signin.jpg') {
    return new Promise((resolve) => {
      const arr = dataURL.split(',')
      const mime = arr[0].match(/:(.*?);/)[1]
      const bstr = atob(arr[1])
      let n = bstr.length
      const u8arr = new Uint8Array(n)
      while (n--) {
        u8arr[n] = bstr.charCodeAt(n)
      }
      resolve(new Blob([u8arr], { type: mime }))
    })
  },

  /**
   * 将canvas转换为Blob对象
   * @param {HTMLCanvasElement} canvas canvas元素
   * @param {string} type 图片类型
   * @param {number} quality 图片质量
   * @returns {Promise<Blob>} Blob对象
   */
  canvasToBlob(canvas, type = 'image/jpeg', quality = 0.8) {
    return new Promise((resolve) => {
      canvas.toBlob(resolve, type, quality)
    })
  },

  /**
   * 压缩图片
   * @param {File|Blob} file 原始图片文件
   * @param {number} maxWidth 最大宽度
   * @param {number} maxHeight 最大高度
   * @param {number} quality 压缩质量
   * @returns {Promise<Blob>} 压缩后的图片
   */
  compressImage(file, maxWidth = 800, maxHeight = 600, quality = 0.8) {
    return new Promise((resolve) => {
      const canvas = document.createElement('canvas')
      const ctx = canvas.getContext('2d')
      const img = new Image()
      
      img.onload = () => {
        // 计算压缩后的尺寸
        let { width, height } = img
        
        if (width > height) {
          if (width > maxWidth) {
            height = (height * maxWidth) / width
            width = maxWidth
          }
        } else {
          if (height > maxHeight) {
            width = (width * maxHeight) / height
            height = maxHeight
          }
        }
        
        canvas.width = width
        canvas.height = height
        
        // 绘制压缩后的图片
        ctx.drawImage(img, 0, 0, width, height)
        
        // 转换为Blob
        canvas.toBlob(resolve, 'image/jpeg', quality)
      }
      
      img.src = URL.createObjectURL(file)
    })
  }
}

/**
 * 签到工具函数
 */
export const signinUtils = {
  /**
   * 验证图片文件
   * @param {File} file 图片文件
   * @returns {Object} 验证结果
   */
  validateImageFile(file) {
    const maxSize = 5 * 1024 * 1024 // 5MB
    const allowedTypes = ['image/jpeg', 'image/jpg', 'image/png', 'image/webp']
    
    if (!file) {
      return { isValid: false, message: '请选择图片文件' }
    }
    
    if (!allowedTypes.includes(file.type)) {
      return { isValid: false, message: '只支持JPG、PNG、WEBP格式的图片' }
    }
    
    if (file.size > maxSize) {
      return { isValid: false, message: '图片文件不能超过5MB' }
    }
    
    return { isValid: true, message: '图片文件有效' }
  },

  /**
   * 获取当前用户ID
   * @returns {string} 用户ID
   */
  getCurrentUserId() {
    return localStorage.getItem('userId') || sessionStorage.getItem('userId') || '1'
  },

  /**
   * 获取当前直播名称
   * @param {string} fallbackTitle 备用标题
   * @returns {string} 直播名称
   */
  getCurrentLiveName(fallbackTitle) {
    // 优先使用传入的备用标题
    if (fallbackTitle) {
      return fallbackTitle
    }
    
    // 从localStorage获取
    const storedLiveName = localStorage.getItem('currentLiveName')
    if (storedLiveName) {
      return storedLiveName
    }
    
    // 尝试从sessionStorage获取
    const sessionLiveName = sessionStorage.getItem('currentLiveName')
    if (sessionLiveName) {
      return sessionLiveName
    }
    
    // 最后的默认值
    return '默认直播'
  },

  /**
   * 格式化文件大小
   * @param {number} bytes 字节数
   * @returns {string} 格式化后的大小
   */
  formatFileSize(bytes) {
    if (bytes === 0) return '0 Bytes'
    
    const k = 1024
    const sizes = ['Bytes', 'KB', 'MB', 'GB']
    const i = Math.floor(Math.log(bytes) / Math.log(k))
    
    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]
  }
}

export default signinApiService
